package controllers

import (
	"fmt"
	"ix-brow/models"
	"ix-brow/services"
	"log"
	"net/http"
	"time"

	"github.com/gin-gonic/gin"
)

// 激活请求体
type ActivateRequest struct {
	Username           string `json:"username" binding:"required"`
	BaseBrowserAccount string `json:"base_browser_account" binding:"required"` // 基础浏览器账号
	ActivateTime       int64  `json:"activate_time" binding:"required"`        // Unix时间戳，单位秒
}

// 激活响应体
type ActivateResponse struct {
	Code    int         `json:"code"`
	Message string      `json:"message"`
	Data    interface{} `json:"data,omitempty"`
}

// ExternalApiResponse 对外API的标准响应结构
type ExternalApiResponse struct {
	Code    int         `json:"code"`
	Message string      `json:"message"`
	Data    interface{} `json:"data,omitempty"`
}

type pageArg struct {
	Email string `json:"email"`
	Page  int    `json:"page"`
	Size  int    `json:"size"`
}

// 浏览器激活处理
func ActivateBrowser(c *gin.Context) {
	var req ActivateRequest
	if err := c.ShouldBindJSON(&req); err != nil {
		c.JSON(http.StatusBadRequest, ActivateResponse{
			Code:    400,
			Message: "无效的请求参数",
		})
		return
	}

	// 验证激活时间不能小于当前时间
	activateTime := time.Unix(req.ActivateTime, 0)
	if activateTime.Before(time.Now()) {
		c.JSON(http.StatusBadRequest, ActivateResponse{
			Code:    400,
			Message: "激活时间不能小于当前时间",
		})
		return
	}
	// 获取当前时间
	currentDate := time.Now().Format("20060102150405")
	// 使用FindUserByUsername查找用户是否存在（不检查浏览器类型）
	userExists, existingUser, existingGroups, existingBrowsers := models.FindUserByUsername(req.Username)
	// 如果用户存在
	if userExists {
		// 用户应该只有一个组，但以防万一
		if len(existingGroups) > 1 {
			errMsg := fmt.Sprintf("用户 %s 应该只有一个组但出现了多个，这违反了业务规则", req.Username)
			log.Printf("错误: %s", errMsg)
			c.JSON(http.StatusInternalServerError, ActivateResponse{
				Code:    500,
				Message: errMsg,
			})
			return
		}
		// 用户应该只有一个组
		activeGroup := &existingGroups[0]
		// 检查该组下是否有指定类型的浏览器
		var matchingBrowser *models.Browser
		for _, browser := range existingBrowsers {
			if browser.GroupID == activeGroup.ID && browser.BrowserType == req.BaseBrowserAccount {
				matchingBrowser = &browser
				break
			}
		}

		// 如果找到了指定类型的浏览器，则更新其过期时间
		if matchingBrowser != nil {
			matchingBrowser.ExpirationTime = activateTime
			if err := models.UpdateBrowser(matchingBrowser); err != nil {
				c.JSON(http.StatusInternalServerError, ActivateResponse{
					Code:    500,
					Message: fmt.Sprintf("更新浏览器信息失败: %v", err),
				})
				return
			}

			c.JSON(http.StatusOK, ActivateResponse{
				Code:    200,
				Message: "浏览器续期成功",
				Data: map[string]interface{}{
					"username":        existingUser.Username,
					"user_id":         existingUser.ID,
					"group_id":        activeGroup.GroupID,
					"group_name":      activeGroup.GroupName,
					"browser_type":    matchingBrowser.BrowserType,
					"browser_name":    matchingBrowser.BrowserName,
					"expiration_time": matchingBrowser.ExpirationTime,
				},
			})
			return
		}

		// 如果没有找到指定类型的浏览器，在现有组下创建新浏览器
		api := services.NewIxBrowserAPI()

		// 首先根据基础浏览器账号查找对应的浏览器ID
		baseBrowserID, baseBrowserTargName, err := api.FindBrowserByName(req.BaseBrowserAccount)
		if err != nil {
			c.JSON(http.StatusInternalServerError, ActivateResponse{
				Code:    500,
				Message: fmt.Sprintf("查找基础浏览器失败: %v", err),
			})
			return
		}

		// 复制浏览器到现有组 - 按照约定格式
		newBrowserID, err := api.CopyBrowser(baseBrowserID, activeGroup.GroupID)
		if err != nil {
			c.JSON(http.StatusInternalServerError, ActivateResponse{
				Code:    500,
				Message: fmt.Sprintf("复制浏览器失败: %v", err),
			})
			return
		}

		// 为现有用户在现有组下创建新的浏览器记录
		newBrowser := models.Browser{
			GroupID:           activeGroup.ID,
			ExternalBrowserID: newBrowserID,
			BrowserName:       req.BaseBrowserAccount,
			BrowserType:       req.BaseBrowserAccount,
			BrowserTargName:   baseBrowserTargName,
			ExpirationTime:    activateTime,
			Active:            true,
		}

		if err := models.DB.Create(&newBrowser).Error; err != nil {
			c.JSON(http.StatusInternalServerError, ActivateResponse{
				Code:    500,
				Message: fmt.Sprintf("保存浏览器信息失败: %v", err),
			})
			return
		}

		// 返回成功响应
		c.JSON(http.StatusOK, ActivateResponse{
			Code:    200,
			Message: "新浏览器类型激活成功",
			Data: map[string]interface{}{
				"username":        existingUser.Username,
				"user_id":         existingUser.ID,
				"group_id":        activeGroup.GroupID,
				"group_name":      activeGroup.GroupName,
				"browser_type":    newBrowser.BrowserType,
				"browser_name":    newBrowser.BrowserName,
				"expiration_time": newBrowser.ExpirationTime,
			},
		})
		return
	}

	// 用户不存在，创建全新用户激活流程
	api := services.NewIxBrowserAPI()

	// 按照约定格式创建用户名
	formattedUsername := fmt.Sprintf("%s_%s", currentDate, req.Username)

	// 1. 创建分组 - 按照约定格式
	groupName := fmt.Sprintf("%s_%s", currentDate, req.Username)
	groupID, err := api.CreateGroup(groupName)
	if err != nil {
		c.JSON(http.StatusInternalServerError, ActivateResponse{
			Code:    500,
			Message: fmt.Sprintf("创建分组失败: %v", err),
		})
		return
	}

	// 首先根据基础浏览器账号查找对应的浏览器ID
	baseBrowserID, baseBrowserTargName, err := api.FindBrowserByName(req.BaseBrowserAccount)
	if err != nil {
		c.JSON(http.StatusInternalServerError, ActivateResponse{
			Code:    500,
			Message: fmt.Sprintf("查找基础浏览器失败: %v", err),
		})
		return
	}

	// 2. 复制浏览器 - 按照约定格式
	newBrowserID, err := api.CopyBrowser(baseBrowserID, groupID)
	if err != nil {
		c.JSON(http.StatusInternalServerError, ActivateResponse{
			Code:    500,
			Message: fmt.Sprintf("复制浏览器失败: %v", err),
		})
		return
	}

	// 3. 创建员工
	employeeName := formattedUsername // 员工名与用户名一致
	_, err = api.CreateEmployee(employeeName, req.Username, groupID)
	if err != nil {
		c.JSON(http.StatusInternalServerError, ActivateResponse{
			Code:    500,
			Message: fmt.Sprintf("创建员工失败: %v", err),
		})
		return
	}

	// 4. 保存用户到数据库（创建用户、分组和浏览器记录）
	newUser, newGroup, newBrowser, err := models.CreateUserWithGroupAndBrowser(
		req.Username,
		formattedUsername,
		groupName,
		groupID,
		req.BaseBrowserAccount,
		req.BaseBrowserAccount,
		baseBrowserTargName,
		activateTime,
	)
	if err != nil {
		c.JSON(http.StatusInternalServerError, ActivateResponse{
			Code:    500,
			Message: fmt.Sprintf("保存用户信息失败: %v", err),
		})
		return
	}

	// 5. 更新浏览器的外部ID
	newBrowser.ExternalBrowserID = newBrowserID
	if err := models.UpdateBrowser(newBrowser); err != nil {
		// 只记录错误，不影响主流程
		fmt.Printf("更新浏览器外部ID失败: %v", err)
	}

	// 返回成功响应
	c.JSON(http.StatusOK, ActivateResponse{
		Code:    200,
		Message: "新用户激活成功",
		Data: map[string]interface{}{
			"username":              employeeName,
			"user_id":               newUser.ID,
			"group_id":              newGroup.GroupID,
			"group_name":            newGroup.GroupName,
			"browser_type":          newBrowser.BrowserType,
			"browser_name":          newBrowser.BrowserName,
			"base_browser_targName": baseBrowserTargName,
			"expiration_time":       newBrowser.ExpirationTime,
		},
	})
}

// GetUserBrowsersExternal 处理外部查询用户浏览器信息的请求 (分页)
func GetUserBrowsersExternal(c *gin.Context) {
	var req pageArg
	if err := c.ShouldBindJSON(&req); err != nil {
		c.JSON(http.StatusBadRequest, ActivateResponse{
			Code:    400,
			Message: "无效的请求参数",
		})
		return
	}
	//打印参数
	log.Printf("GetUserBrowsersExternal req:%v \r\n", req)
	// --- 调用模型层 ---
	browsers, total, err := models.GetBrowsersByUsername(req.Email, req.Page, req.Size)
	if err != nil {
		// 用户未找到
		if err.Error() == fmt.Sprintf("用户 '%s' 未找到或未激活", req.Email) {
			c.JSON(http.StatusNotFound, gin.H{
				"code":     404, // 或者其他错误码
				"messages": err.Error(),
				"notice":   "暂无公告",
			})
		} else { // 其他内部错误
			c.JSON(http.StatusInternalServerError, gin.H{
				"code":     500, // 或者其他错误码
				"messages": err.Error(),
				"notice":   "暂无公告",
			})
		}
		return
	}

	// --- 构造成功响应 ---
	c.JSON(http.StatusOK, gin.H{
		"code": 1000,
		"data": gin.H{
			"list": browsers,
			"pagination": gin.H{
				"page":  req.Page,
				"size":  req.Size,
				"total": total,
			},
		},
		"messages": "success",
		"notice":   "暂无公告",
	})
}
